﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<string>
#include<unordered_map>
#include<algorithm>

using namespace std;

int Common_divisor(int a, int b)//求a，b最大公约数，输入保证a<b
{
    for (int i = a; i >= 1; i--)
    {
        if (a % i == 0 && b % i == 0)
        {
            return i;
        }
    }
    return 1;
}

//int main()
//{
//    int n = 0, a = 0;
//    while (cin >> n >> a)
//    {
//        // vector<int> v(n,0);
//        for (int i = 0; i < n; i++)
//        {
//            // cin>>v[i];
//            int b;
//            cin >> b;
//            if (a >= b)
//            {
//                a += b;
//            }
//            else
//            {
//                a += Common_divisor(a, b);
//            }
//        }
//        cout << a << endl;
//    }
//    return 0;
//}

//int main()
//{
//    string s;
//    cin >> s;
//    vector<vector<int> >dp(s.size(), vector<int>(s.size(), 0));
//    //dp[i][j]指字符串s在[i, j]范围内最长的回文子序列的长度。
//    //在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。
//    //如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;
//    //如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子串的长度，那么分别加入s[i]、s[j]   看看哪一个可以组成最长的回文子序列。
//    //加入s[j]的回文子序列长度为dp[i + 1][j]。
//    //加入s[i]的回文子序列长度为dp[i][j - 1]
//    //那么dp[i][j]一定是取最大的，即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
//    for (int i = 0; i < s.size(); i++)
//    {
//        dp[i][i] = 1;
//    }
//    for (int i = s.size() - 1; i >= 0; i--)
//    {
//        for (int j = i + 1; j < s.size(); j++)
//        {
//            if (s[i] == s[j])
//            {
//                dp[i][j] = dp[i + 1][j - 1] + 2;
//            }
//            else
//            {
//                dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]);
//            }
//        }
//    }
//    cout << dp[0][s.size() - 1];
//    return 0;
//}

class Solution 
{
public:
    static bool comp(pair<int, int> p1, pair<int, int> p2)
    {
        return p1.first < p2.first;
    }

    bool hostschedule(vector<vector<int> >& schedule)
    {
        int n = schedule.size();
        vector<pair<int, int>> v;
        for (int i = 0; i < n; i++)//将开始和结束时间组成pair对，再插入
        {
            v.emplace_back(schedule[i][0], schedule[i][1]);
        }
        sort(v.begin(), v.end(), comp);//按开始时间从大到小排序
        for (int i = 1; i < n; i++)
        {
            if (v[i].first < v[i - 1].second)//该场的开始时间小于前一场的结束时间，则一个主持人不可能完成
            {
                return false;
            }
        }
        return true;
        // write code here
    }
};

//int main()
//{
//    Solution S;
//
//	return 0;
//}

//int main()
//{
//    int n = 0;
//    cin >> n;
//    vector<int> v(n + 1, 0);
//    int i = 0;
//    int sum = 0;
//    for (i = 1; i <= n; i++)
//    {
//        cin >> v[i];
//        sum += v[i];
//    }
//    if (sum % 2 != 0)//和不是偶数，不可能分成两个和相等的子串
//    {
//        cout << "false" << endl;
//        return 0;
//    }
//    vector<int> dp(sum / 2 + 1, 0);
//    int flag = 1;
//    for (int i = 1; i <= n; ++i)
//    {
//        for (int j = sum / 2; j >= v[i]; --j)
//        {
//            if (j == v[i] || dp[j - v[i]] != 0)
//            {
//                dp[j] = 1;
//            }
//            else
//            {
//                dp[j] = 0;
//            }
//        }
//
//    }
//    flag = dp[sum / 2];
//
//    if (flag)
//    {
//        cout << "true" << endl;
//    }
//    else
//    {
//        cout << "false" << endl;
//    }
//    return 0;
//}

//int main()
//{
//    string str;
//    cin >> str;
//    int len = 0;
//    int i = 0;
//    while (i < str.size())
//    {
//        int l = i - 1, r = i;
//        while (l >= 0 && r < str.size())//检测是否是偶数个对称的子串
//        {
//            if (str[l] != str[r])
//            {
//                break;
//            }
//            l--;
//            r++;
//        }
//        if (r - l - 1 > 1 && r - l - 1 < len)
//        {
//            len = r - l - 1;
//        }
//        l = i - 1, r = i + 1;
//        while (l >= 0 && r < str.size())//检测是否是以str[i]为对称轴的子串
//        {
//            if (str[l] != str[r])
//            {
//                break;
//            }
//            l--;
//            r++;
//        }
//        if (r - l - 1 > 1 && r - l - 1 < len)
//        {
//            len = r - l - 1;
//        }
//        i++;
//    }
//    if (len <= 1)
//    {
//        cout << -1 << endl;
//    }
//    else
//    {
//        cout << len << endl;
//    }
//    return 0;
//}

int main()
{
    string s;
    cin >> s;
    int ret = -1; // 有可能没有回⽂串
    int n = s.size();
    for (int i = 0; i < n; i++)
    {
        if (i + 1 < n && s[i] == s[i + 1]) // 判断⻓度为 2 的⼦串
        {
            ret = 2;
        }
        if (i + 2 < n && s[i] == s[i + 2]) // 判断⻓度为 3 的⼦串
        {
            ret = 3;
        }
    }
    cout << ret << endl;
    return 0;
}